package com.supply.dl.utils;

import java.math.BigDecimal;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 类描述：　[字符串的工具类]<br/>
 * 项目名称：[AndroidArchitecture]<br/>
 * 包名：　　[com.yeung.architecture.utils]<br/>
 * 创建人：　[杨挺]<br/>
 * 创建时间：[2016/07/28 0006 14:51]<br/>
 * 版本：　　[v1.0.0]<br/>
 */
public class StringUtils {
    /**
     * 判断一个字符串是否为空(去掉空格)
     *
     * @param str 要验证的字符串
     * @return 是空的话，返回true|其他false
     */
    public static boolean isBlank(String str) {
        return (str == null || str.trim().length() == 0);
    }

    /**
     * Returns true if the parameter is null or of zero length
     */
    public static boolean isEmpty(final CharSequence s) {
        return s == null || s.length() == 0;
    }

    /**
     * 字符串不为null,"","null"就为可用
     *
     * @param s
     * @return
     */
    public static boolean isCanUse(String s) {
        if (isBlank(s) || "null".equals(s))
            return false;
        return true;
    }

    /**
     * Returns true if the parameter is null or contains only whitespace
     */
    public static boolean isBlank(final CharSequence s) {
        if (s == null) {
            return true;
        }
        for (int i = 0; i < s.length(); i++) {
            if (!Character.isWhitespace(s.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * @since 4.4
     */
    public static boolean containsBlanks(final CharSequence s) {
        if (s == null) {
            return false;
        }
        for (int i = 0; i < s.length(); i++) {
            if (Character.isWhitespace(s.charAt(i))) {
                return true;
            }
        }
        return false;
    }

    public static String toDBC(String input) {
        char[] c = input.toCharArray();
        for (int i = 0; i < c.length; i++) {
            if (c[i] == 12288) {
                c[i] = (char) 32;
                continue;
            }
            if (c[i] > 65280 && c[i] < 65375)
                c[i] = (char) (c[i] - 65248);
        }
        return new String(c);
    }

    /**
     * 判断一个字符串是不是数字
     *
     * @param str 要验证的字符串
     * @return true 是数字 false 不是
     */
    public static boolean isNumeric(CharSequence str) {
        if (StringUtils.isEmpty(str))
            return false;
        Pattern pattern = Pattern.compile("[0-9]+");
        Matcher isNum = pattern.matcher(str);
        return isNum.matches();
    }

    public static String trim(String s) {
        if (s.charAt(0) == ' ') {
            s = s.substring(1, s.length());
        }
        if (s.charAt(s.length() - 1) == ' ') {
            s = s.substring(0, s.length() - 1);
        }
        return s;
    }

    public static String mergeBlank(String s) {
        int numberBlank;
        String a1;//字符串的第一部分
        String a2;//字符串的第二部分
        for (int index = 0; index < s.length(); index++) {//循环整个字符串，判断是否有连续空格
            numberBlank = getBlankNumber(s, index);
            if (numberBlank >= 2) {//根据连续空格的个数以及当前的位置，截取字符串
                a1 = s.substring(0, index);
                a2 = s.substring(index + numberBlank - 1, s.length());
                s = a1 + a2;//合并字符串
            }
        }

        return s.trim();
    }

    /**
     * 超过2个回车识别为2个
     */
    public static String mergeBlankTwo(String s) {
        try {
            int numberBlank;
            String a1;//字符串的第一部分
            String a2;//字符串的第二部分
            for (int index = 0; index < s.length(); index++) {//循环整个字符串，判断是否有连续空格
                numberBlank = getBlankNumber(s, index);
                if (numberBlank > 2) {//根据连续空格的个数以及当前的位置，截取字符串
                    a1 = s.substring(0, index);
                    a2 = s.substring(index + numberBlank - 2, s.length());
                    s = a1 + a2;//合并字符串
                }
            }
        } catch (Exception e) {
            return mergeBlank(s);
        }
        return s.trim();
    }

    /**
     * 验证字符串里的字符是不是全是空字符
     */
    public static boolean isBlankStr(CharSequence s) {
        if (s == null)
            return true;
        int length = s.length();
        if (length <= 0)
            return true;
        int blankNum = getBlankNumber(s, 0);
        return blankNum == length;
    }

    /**
     * 获取字符串中的空格数
     *
     * @return 空格数
     */
    public static int getBlankNumber(CharSequence s, int index) {
        int num = 0;
        if (index < s.length()) {
            for (int i = index; i < s.length(); i++) {
                char ch = s.charAt(i);
                if (ch == ' ' || ch == '\n') {
                    num++;
                } else {
                    break;
                }
            }
        }
        return num;
    }

    /**
     * 是否全是空格或者回车
     *
     * @param content 内容
     */
    public static boolean spaceOrEnter(String content) {
        if (content == null || content.length() == 0)
            return false;
        try {
            Pattern pattern = Pattern.compile("\\s*|\t|\r|\n");
            int num = 0;
            for (int i = 0; i < content.length(); i++) {
                String tem = content.substring(i, i + 1);
                Matcher isChinese = pattern.matcher(tem);
                if (isChinese.matches()) {
                    num++;
                }
            }
            return num == content.length();
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 是否是手机号码
     *
     * @param mobiles 要验证的字符串
     * @return 是true/不是false
     */
    public static boolean isMobileNo(String mobiles) {
        return isMobileNo(mobiles, "^((11)|(12)|(13)|(14)|(15)|(16)|(17)|(18)|(19))\\d{9}$");
    }

    /**
     * 是否是手机号码
     *
     * @param mobiles 要验证的字符串
     * @return 是true/不是false
     */
    public static boolean isMobileNo(String mobiles, String pattern) {
        if (StringUtils.isEmpty(mobiles))
            return false;
        if (isEmpty(pattern)) {
            return true;
        }
        try {
            Pattern p = Pattern.compile(pattern);
            Matcher m = p.matcher(mobiles);
            return m.matches();
        } catch (Exception e) {
            return true;
        }
    }

    /**
     * 数据格式转换
     *
     * @param point
     * @return
     */
    public static String numeric(int point) {
        String numStr = "";
        if (div(point, 1000, 2) > 1) {
            numStr = div(point, 1000, 2) + "k";
        } else {
            numStr = point + "";
        }
        return numStr;
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入。
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double div(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
}
